// 3D模型 EventBus 管理器
import mitt from 'mitt'

// 创建全局唯一的 EventBus 实例
const eventBus = mitt()

// 事件类型定义
export const MODEL_EVENTS = {
    // 模型变化事件
    MODEL_CHANGED: 'model:changed',
    MODEL_LOADED: 'model:loaded',
    MODEL_LOADING: 'model:loading',
    MODEL_ERROR: 'model:error',
    MODEL_CLEARED: 'model:cleared',

    // 生成状态事件
    GENERATE_START: 'generate:start',
    GENERATE_PROGRESS: 'generate:progress',
    GENERATE_SUCCESS: 'generate:success',
    GENERATE_ERROR: 'generate:error',

    // 历史记录事件
    HISTORY_UPDATED: 'history:updated',
    HISTORY_ITEM_SELECTED: 'history:selected'
}

// EventBus 管理类
class ModelEventBus {
    constructor() {
        this.eventBus = eventBus
        this.listeners = new Map() // 用于追踪监听器，便于清理
    }

    // 发送模型变化事件
    emitModelChanged(modelData) {
        console.log('[EventBus] 发送模型变化事件:', modelData)
        this.eventBus.emit(MODEL_EVENTS.MODEL_CHANGED, {
            type: 'changed',
            data: modelData,
            timestamp: Date.now()
        })
    }

    // 发送模型加载中事件
    emitModelLoading(loadingInfo) {
        console.log('[EventBus] 发送模型加载中事件:', loadingInfo)
        this.eventBus.emit(MODEL_EVENTS.MODEL_LOADING, {
            type: 'loading',
            data: loadingInfo,
            timestamp: Date.now()
        })
    }

    // 发送模型加载完成事件
    emitModelLoaded(modelData) {
        console.log('[EventBus] 发送模型加载完成事件:', modelData)
        this.eventBus.emit(MODEL_EVENTS.MODEL_LOADED, {
            type: 'loaded',
            data: modelData,
            timestamp: Date.now()
        })
    }

    // 发送模型错误事件
    emitModelError(error) {
        console.log('[EventBus] 发送模型错误事件:', error)
        this.eventBus.emit(MODEL_EVENTS.MODEL_ERROR, {
            type: 'error',
            data: error,
            timestamp: Date.now()
        })
    }

    // 发送模型清除事件
    emitModelCleared() {
        console.log('[EventBus] 发送模型清除事件')
        this.eventBus.emit(MODEL_EVENTS.MODEL_CLEARED, {
            type: 'cleared',
            data: null,
            timestamp: Date.now()
        })
    }

    // 发送生成开始事件
    emitGenerateStart(config) {
        this.eventBus.emit(MODEL_EVENTS.GENERATE_START, {
            type: 'generate_start',
            data: config,
            timestamp: Date.now()
        })
    }

    // 发送生成进度事件
    emitGenerateProgress(progress) {
        this.eventBus.emit(MODEL_EVENTS.GENERATE_PROGRESS, {
            type: 'generate_progress',
            data: progress,
            timestamp: Date.now()
        })
    }

    // 发送生成成功事件
    emitGenerateSuccess(result) {
        this.eventBus.emit(MODEL_EVENTS.GENERATE_SUCCESS, {
            type: 'generate_success',
            data: result,
            timestamp: Date.now()
        })

        // 同时发送模型变化事件
        this.emitModelChanged(result)
    }

    // 发送历史记录选择事件
    emitHistoryItemSelected(historyItem) {
        console.log('[EventBus] 发送历史记录选择事件:', historyItem)
        this.eventBus.emit(MODEL_EVENTS.HISTORY_ITEM_SELECTED, {
            type: 'history_selected',
            data: historyItem,
            timestamp: Date.now()
        })

        // 同时发送模型变化事件
        this.emitModelChanged(historyItem)
    }

    // 监听事件（带自动清理功能）
    on(eventName, handler, componentId) {
        console.log(`[EventBus] 注册监听器: ${eventName} (组件: ${componentId})`)

        this.eventBus.on(eventName, handler)

        // 记录监听器用于清理
        if (!this.listeners.has(componentId)) {
            this.listeners.set(componentId, [])
        }
        this.listeners.get(componentId).push({ eventName, handler })
    }

    // 监听模型变化事件
    onModelChanged(handler, componentId = 'default') {
        this.on(MODEL_EVENTS.MODEL_CHANGED, handler, componentId)
    }

    // 监听模型加载事件
    onModelLoaded(handler, componentId = 'default') {
        this.on(MODEL_EVENTS.MODEL_LOADED, handler, componentId)
    }

    // 监听模型错误事件
    onModelError(handler, componentId = 'default') {
        this.on(MODEL_EVENTS.MODEL_ERROR, handler, componentId)
    }

    // 监听生成成功事件
    onGenerateSuccess(handler, componentId = 'default') {
        this.on(MODEL_EVENTS.GENERATE_SUCCESS, handler, componentId)
    }

    // 监听历史记录选择事件
    onHistoryItemSelected(handler, componentId = 'default') {
        this.on(MODEL_EVENTS.HISTORY_ITEM_SELECTED, handler, componentId)
    }

    // 移除特定组件的所有监听器
    off(componentId) {
        console.log(`[EventBus] 清理组件监听器: ${componentId}`)

        const componentListeners = this.listeners.get(componentId)
        if (componentListeners) {
            componentListeners.forEach(({ eventName, handler }) => {
                this.eventBus.off(eventName, handler)
            })
            this.listeners.delete(componentId)
        }
    }

    // 移除所有监听器
    offAll() {
        console.log('[EventBus] 清理所有监听器')
        this.eventBus.all.clear()
        this.listeners.clear()
    }

    // 获取事件统计信息（调试用）
    getEventStats() {
        return {
            totalEvents: Object.keys(this.eventBus.all).length,
            registeredComponents: Array.from(this.listeners.keys()),
            eventTypes: Object.values(MODEL_EVENTS)
        }
    }
}

// 创建并导出单例实例
const modelEventBus = new ModelEventBus()

export default modelEventBus

// 导出便捷方法
export const {
    emitModelChanged,
    emitModelLoading,
    emitModelLoaded,
    emitModelError,
    emitModelCleared,
    emitGenerateStart,
    emitGenerateProgress,
    emitGenerateSuccess,
    emitHistoryItemSelected,
    onModelChanged,
    onModelLoaded,
    onModelError,
    onGenerateSuccess,
    onHistoryItemSelected,
    off,
    offAll,
    getEventStats
} = modelEventBus